{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## _*Using Qiskit Aqua for partition problems*_\n",
    "\n",
    "This Qiskit Aqua Optimization notebook demonstrates how to use the VQE algorithm to compute a balanced partition of a set of numbers. This problem is known as \"number partitioning\" or simply \"partition\" in computer science.\n",
    "\n",
    "The problem is defined as follows. We are given a set of numbers $S$, and we want to determine a partition of $S$ into disjoint sets $S_1, S_2$ such that $|\\sum_{a \\in S_1} - \\sum_{a \\in S_2}|$ is minimized.\n",
    "\n",
    "The list of numbers provided as an input is used first to generate an Ising Hamiltonian, which is then passed as an input to VQE.  As a reference, this notebook also computes the maximum stable set using the NumPyMinimumEigensolver classical algorithm and the solver embedded in the commercial IBM CPLEX product (if it is available in the system and the user has followed the necessary configuration steps in order for Qiskit Aqua to find it).  Please refer to the Qiskit Aqua Optimization documentation for installation and configuration details for CPLEX."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from qiskit import BasicAer\n",
    "from qiskit.aqua import QuantumInstance\n",
    "from qiskit.optimization.applications.ising import partition\n",
    "from qiskit.aqua.algorithms import NumPyMinimumEigensolver, VQE\n",
    "from qiskit.aqua.components.optimizers import L_BFGS_B\n",
    "from qiskit.circuit.library import TwoLocal\n",
    "from qiskit.optimization.applications.ising.common import (read_numbers_from_file,\n",
    "                                                           random_number_list, sample_most_likely)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here an Operator instance is created for our Hamiltonian. In this case the Paulis are from an Ising Hamiltonian of the number partitioning problem (expressed in minimization form). Rather than minimizing the absolute value of the difference of the sum of numbers into two sets, we minimize the difference square.\n",
    "\n",
    "We load a small instance of the problem."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 1  3  4  7 10 13 15 16]\n"
     ]
    }
   ],
   "source": [
    "number_list = read_numbers_from_file('sample.partition')\n",
    "qubitOp, offset = partition.get_operator(number_list)\n",
    "print(number_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We also offer a function to generate a set of numbers as a input."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 9  8 23  4  2]\n"
     ]
    }
   ],
   "source": [
    "if True:\n",
    "    np.random.seed(8123179)\n",
    "    number_list = random_number_list(5, weight_range=25)\n",
    "    qubitOp, offset = partition.get_operator(number_list)\n",
    "    print(number_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here we test for the presence of algorithms we want to use in this notebook. If Aqua is installed correctly `NumPyMinimumEigensolver` and `VQE` will always be found. `ClassicalCPLEX` is dependent on CPLEX being installed (see introduction above). CPLEX is *not required* but if installed then this notebook will demonstrate the `ClassicalCPLEX` algorithm , that uses CPLEX, to compute partition as well."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['NumPyMinimumEigensolver', 'ClassicalCPLEX', 'VQE']\n"
     ]
    }
   ],
   "source": [
    "to_be_tested_algos = ['NumPyMinimumEigensolver', 'ClassicalCPLEX', 'VQE']\n",
    "print(to_be_tested_algos)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can now use the Operator without regard to how it was created. Here we will use the NumPyMinimumEigensolver first to return the smallest eigenvalue. Backend is not required since this is computed classically not using quantum computation. The result is a dictionary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "energy: -694.0\n",
      "partition objective: 0.0\n",
      "solution: [1 1 0 1 1]\n",
      "solution objective: 0\n"
     ]
    }
   ],
   "source": [
    "result = NumPyMinimumEigensolver(qubitOp).run()\n",
    "\n",
    "x = sample_most_likely(result.eigenstate)\n",
    "print('energy:', result.eigenvalue.real)\n",
    "print('partition objective:', result.eigenvalue.real + offset)\n",
    "print('solution:', x)\n",
    "print('solution objective:', partition.partition_value(x, number_list))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Note*: If CPLEX is installed then the Aqua ClassicalCPLEX algorithm will be able to be used. If not, then solving this problem using this particular algorithm will simply be skipped. \n",
    "\n",
    "We change the configuration parameters to solve it with the CPLEX backend. The CPLEX backend can deal with a particular type of Hamiltonian called Ising Hamiltonian, which consists of only Pauli Z at most second order and often for combinatorial optimization problems that can be formulated as quadratic unconstrained binary optimization problems, such as the Number Partitioning problem.\n",
    "\n",
    "Note that for a Number Partitioning problem, since we are computing a bipartition of the set $S$, every binary vector $x$ and its complement (i.e., the vector $y$ such that $y_j = 1 - x_j$ for all $j$) represent exactly the same solution, and will have the same objective function value. Different solution methods may return solutions that look different, but in fact have the same objective function value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Version identifier: 12.10.0.0 | 2019-11-27 | 843d4de\n",
      "CPXPARAM_Read_DataCheck                          1\n",
      "CPXPARAM_Threads                                 1\n",
      "CPXPARAM_MIP_Display                             0\n",
      "CPXPARAM_TimeLimit                               600\n",
      "CPXPARAM_MIP_Tolerances_MIPGap                   0\n",
      "CPXPARAM_MIP_Tolerances_Integrality              0\n",
      "energy: -694.0\n",
      "time: 0.050331075999999975\n",
      "partition objective: 0.0\n",
      "solution: [1 1 0 1 1]\n",
      "solution objective: 0\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    from qiskit.aqua.algorithms import ClassicalCPLEX\n",
    "    result = ClassicalCPLEX(qubitOp, display=0).run()\n",
    "   \n",
    "    x_dict = result['x_sol']\n",
    "    print('energy:', result['energy'])\n",
    "    print('time:', result['eval_time'])\n",
    "    print('partition objective:', result['energy'] + offset)\n",
    "    x = np.array([x_dict[i] for i in sorted(x_dict.keys())])\n",
    "    print('solution:', x)\n",
    "    print('solution objective:', partition.partition_value(x, number_list))\n",
    "except Exception as ex:\n",
    "    print(str(ex))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we want VQE and so change it and add its other configuration parameters. VQE also needs and optimizer and variational form. While we can omit them from the dictionary, such that defaults are used, here we specify them explicitly so we can set their parameters as we desire."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "energy: -693.9999999999553\n",
      "time: 38.03071618080139\n",
      "partition objective: 4.46789272245951e-11\n",
      "solution: [0. 0. 1. 0. 0.]\n",
      "solution objective: 0\n"
     ]
    }
   ],
   "source": [
    "vqe = VQE(qubitOp,\n",
    "          TwoLocal(qubitOp.num_qubits, ['ry', 'rz'], 'cz', reps=3, entanglement='linear'),\n",
    "          L_BFGS_B(maxfun=6000))\n",
    "result = vqe.run(QuantumInstance(BasicAer.get_backend('statevector_simulator')))\n",
    "\n",
    "x = sample_most_likely(result.eigenstate)\n",
    "print('energy:', result.eigenvalue.real)\n",
    "print('time:', result.optimizer_time)\n",
    "print('partition objective:', result.eigenvalue.real + offset)\n",
    "print('solution:', x)\n",
    "print('solution objective:', partition.partition_value(x, number_list))"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}
